Before the advent of personal computers, large, expensive, mainframe computers dominated the landscape of digital computing. Each mainframe computer typically served multiple users that interfaced with the mainframe computer through terminals that had a display device, such as a cathode-ray tube (CRT) screen, and an input device, such as a keyboard. Such terminals are nowadays commonly referred to as 20 “dumb terminals” because they performed only basic display and input functions and had at most some rudimental digital processing capability that was not sufficient for independently running software applications.
The display provided by the “dumb” terminals was character-based, i.e., the display comprised alphanumeric letters. During operation, the user input entered through the keyboard is transmitted to the mainframe computer, and the output in the form of letters and numbers was sent to the terminal and displayed on its screen for viewing by the user.
In the beginning of the age of personal computers, personal computers were small machines with limited computing power and resources. They typically operated as individual units in the sense that each computer had its own operating system, ran its own software applications, received user input from its own input devices, and sent the user interface to its own CRT for display. In the early days, the PC interface was, like the dumb terminals for mainframes, based on alphanumeric characters. Graphic user interface, however, soon replaced the character-based display and became the norm for software applications designed to run on personal computers and networks based on personal computers.
Over time, the computing power of personal computers in terms of both hardware capabilities and software sophistication has increased tremendously. Many personal computers nowadays possess computing power and resources rivaling some small mainframe computers in the past. At the same time, networking of personal computers has become prevalent at workplaces. Due to these developments, there arises the possibility to run a software application on a server computer, which may be a network server, with the user running the application sitting at a remote client computer connected to the server computer through a network. In the capacity of a remote terminal, the client computer functions like a dumb terminal of the old days in that it forwards the user input to the server computer for processing and displays the user interface received from the server computer on its screen for viewing by the user in a proposed scheme for remote terminal service, the client computer functions entirely in a slave mode in that the server computer tells the client computer exactly what to put on the user interface screen.
There are, however, many differences between a client computer functioning as a remote terminal and a dumb terminal of the past. One of the major differences is that the user interface has become much more sophisticated. A user interface screen on current personal computers is graphics-oriented and includes various graphic components such as text strings, icons, windows, etc. To enable the remote terminal to display the interface screen, the terminal server has to pass data regarding each graphic component, such as their bitmaps and coordinates, to the client computer. Because the remote terminal is connected to the server computer through a network, the data transmission can be quite time consuming, and the efficient use of the network bandwidth has to be considered in designing the remote terminal service system. If the amount of graphics data that have to be sent to the remote terminal is large, the network data transmission can become a bottleneck and negatively impacts the display performance of the remote terminal.
The efficient use of network bandwidth in a remote terminal session is especially import for displaying characters. An interface screen may contain many text strings each having multiple characters. Generally, each character has a Unicode designation, and the graphics engine of the client computer can use the Unicode designation and the font information of a character to render it for display. Thus, the server computer may instruct the client computer to display a text string by sending only the Unicode designations and font of the characters in the string to the client computer. This approach, however, does not work in many cases. In the remote terminal server-client scheme, the server and the client may be on different operating system platforms, and the client may not even have the set of fonts that the server has. As a result, the same characters may be rendered differently by the different graphics engines, and the remote terminal may display characters in a form different from what is intended by the server. One solution to avoid this problem is to send glyphs for the characters to be displayed to the terminal client. Each glyph contains the bitmap representation of a character of a given font and size. Sending the glyphs across the network, however, can be quite expensive. A single glyph may be over 256 bytes long. When the user interface screen to be displayed at the remote terminal contains many characters, sending the glyphs to the terminal client may take up a significant portion of network bandwidth.